const DatabaseManager = require('../database/database');

class UserService {
  constructor(dbManager = null) {
    // 如果传入了数据库管理器实例，使用它；否则创建新实例
    this.db = dbManager || new DatabaseManager();
  }

  /**
   * 创建新用户
   * @param {Object} userData - 用户数据
   * @param {string} userData.username - 用户名
   * @param {string} userData.password - 密码
   * @param {string} userData.real_name - 真实姓名
   * @param {string} userData.email - 邮箱
   * @param {string} userData.phone - 电话
   * @param {number} userData.status - 状态 (1: 启用, 0: 禁用)
   * @returns {Promise<number>} 新用户的ID
   */
  async createUser(userData) {
    try {
      // 验证必填字段
      if (!userData.username || !userData.password) {
        throw new Error('用户名和密码不能为空');
      }

      // 检查用户名是否已存在
      const existingUser = await this.findUserByUsername(userData.username);
      if (existingUser) {
        throw new Error('用户名已存在');
      }

      // 设置默认状态
      const user = {
        username: userData.username,
        password: userData.password,
        real_name: userData.real_name || null,
        email: userData.email || null,
        phone: userData.phone || null,
        status: userData.status !== undefined ? userData.status : 1
      };

      const userId = await this.db.insert('users', user);
      return userId;
    } catch (error) {
      console.error('创建用户失败:', error);
      throw error;
    }
  }

  /**
   * 根据ID获取用户
   * @param {number} userId - 用户ID
   * @returns {Promise<Object|null>} 用户信息
   */
  async getUserById(userId) {
    try {
      const user = await this.db.findById('users', userId);
      return user;
    } catch (error) {
      console.error('获取用户失败:', error);
      throw error;
    }
  }

  /**
   * 根据用户名获取用户
   * @param {string} username - 用户名
   * @returns {Promise<Object|null>} 用户信息
   */
  async findUserByUsername(username) {
    try {
      const users = await this.db.findAll('users', { username });
      return users.length > 0 ? users[0] : null;
    } catch (error) {
      console.error('根据用户名查找用户失败:', error);
      throw error;
    }
  }

  /**
   * 获取所有用户
   * @param {Object} filters - 过滤条件
   * @returns {Promise<Array>} 用户列表
   */
  async getAllUsers(filters = {}) {
    try {
      const users = await this.db.findAll('users', filters);
      return users;
    } catch (error) {
      console.error('获取用户列表失败:', error);
      throw error;
    }
  }

  /**
   * 更新用户信息
   * @param {number} userId - 用户ID
   * @param {Object} updateData - 更新数据
   * @returns {Promise<number>} 影响的行数
   */
  async updateUser(userId, updateData) {
    try {
      // 如果更新用户名，检查是否已存在
      if (updateData.username) {
        const existingUser = await this.findUserByUsername(updateData.username);
        if (existingUser && existingUser.id !== userId) {
          throw new Error('用户名已存在');
        }
      }

      // 过滤掉不允许更新的字段
      const allowedFields = ['username', 'password', 'real_name', 'email', 'phone', 'status'];
      const filteredData = {};
      
      Object.keys(updateData).forEach(key => {
        if (allowedFields.includes(key)) {
          filteredData[key] = updateData[key];
        }
      });

      if (Object.keys(filteredData).length === 0) {
        throw new Error('没有有效的更新字段');
      }

      const changes = await this.db.update('users', userId, filteredData);
      return changes;
    } catch (error) {
      console.error('更新用户失败:', error);
      throw error;
    }
  }

  /**
   * 删除用户
   * @param {number} userId - 用户ID
   * @returns {Promise<number>} 影响的行数
   */
  async deleteUser(userId) {
    try {
      const changes = await this.db.delete('users', userId);
      return changes;
    } catch (error) {
      console.error('删除用户失败:', error);
      throw error;
    }
  }

  /**
   * 验证用户登录
   * @param {string} username - 用户名
   * @param {string} password - 密码
   * @returns {Promise<Object|null>} 用户信息
   */
  async validateLogin(username, password) {
    try {
      const user = await this.findUserByUsername(username);
      if (!user) {
        return null;
      }

      // 简单的密码验证（实际应用中应该使用加密）
      if (user.password === password && user.status === 1) {
        // 返回用户信息时排除密码
        const { password: _, ...userInfo } = user;
        return userInfo;
      }

      return null;
    } catch (error) {
      console.error('用户登录验证失败:', error);
      throw error;
    }
  }

  /**
   * 更新用户密码
   * @param {number} userId - 用户ID
   * @param {string} newPassword - 新密码
   * @returns {Promise<number>} 影响的行数
   */
  async updatePassword(userId, newPassword) {
    try {
      if (!newPassword) {
        throw new Error('新密码不能为空');
      }

      const changes = await this.db.update('users', userId, { password: newPassword });
      return changes;
    } catch (error) {
      console.error('更新密码失败:', error);
      throw error;
    }
  }

  /**
   * 启用/禁用用户
   * @param {number} userId - 用户ID
   * @param {number} status - 状态 (1: 启用, 0: 禁用)
   * @returns {Promise<number>} 影响的行数
   */
  async updateUserStatus(userId, status) {
    try {
      if (status !== 0 && status !== 1) {
        throw new Error('状态值必须为0或1');
      }

      const changes = await this.db.update('users', userId, { status });
      return changes;
    } catch (error) {
      console.error('更新用户状态失败:', error);
      throw error;
    }
  }

  /**
   * 搜索用户
   * @param {string} keyword - 搜索关键词
   * @returns {Promise<Array>} 匹配的用户列表
   */
  async searchUsers(keyword) {
    try {
      return new Promise((resolve, reject) => {
        if (!this.db.isInitialized) {
          reject(new Error('数据库未初始化'));
          return;
        }

        const sql = `
          SELECT * FROM users 
          WHERE username LIKE ? 
             OR real_name LIKE ? 
             OR email LIKE ? 
             OR phone LIKE ?
          ORDER BY username
        `;
        
        const searchPattern = `%${keyword}%`;
        this.db.db.all(sql, [searchPattern, searchPattern, searchPattern, searchPattern], (err, rows) => {
          if (err) {
            reject(err);
          } else {
            resolve(rows);
          }
        });
      });
    } catch (error) {
      console.error('搜索用户失败:', error);
      throw error;
    }
  }
}

module.exports = UserService;
